// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.inventory.flows;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.InventoryFlows;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(InventoryFlows.class)
@Setter
@Getter
public class InventoryFlowsSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "InventoryFlows".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("itemId", "p");
    map.put("shopId", "si");
    map.put("stockId", "w");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：
   * </p>
   */
  private String byViewName;

  /**
   * 最早操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operateTimeStart;

  /**
   * 最晚操作时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date operateTimeEnd;

  /**
   * 操作时间 比较(eq)
   */
  private Date operateTimeEq;
  /**
   * 操作时间 比较(neq)
   */
  private Date operateTimeNeq;
  /**
   * 操作时间 比较(gt)
   */
  private Date operateTimeGt;
  /**
   * 操作时间 比较(gte)
   */
  private Date operateTimeGte;
  /**
   * 操作时间 比较(lt)
   */
  private Date operateTimeLt;
  /**
   * 操作时间 比较(lte)
   */
  private Date operateTimeLte;
  /**
   * 操作时间 比较(contains)
   */
  private Date operateTimeContains;
  /**
   * 操作时间 比较(notcontains)
   */
  private Date operateTimeNotcontains;
  /**
   * 操作时间 比较(startswith)
   */
  private Date operateTimeStartswith;
  /**
   * 操作时间 比较(endswith)
   */
  private Date operateTimeEndswith;
  /**
   * 操作时间 比较(isnull)
   */
  private Boolean operateTimeIsnull;
  /**
   * 操作时间 比较(isnotnull)
   */
  private Boolean operateTimeIsnotnull;

  /**
   * 类型(模糊搜索)
   */
  private String documentType;

  /**
   * 类型 比较(eq)
   */
  private String documentTypeEq;
  /**
   * 类型 比较(neq)
   */
  private String documentTypeNeq;
  /**
   * 类型 比较(gt)
   */
  private String documentTypeGt;
  /**
   * 类型 比较(gte)
   */
  private String documentTypeGte;
  /**
   * 类型 比较(lt)
   */
  private String documentTypeLt;
  /**
   * 类型 比较(lte)
   */
  private String documentTypeLte;
  /**
   * 类型 比较(contains)
   */
  private String documentTypeContains;
  /**
   * 类型 比较(notcontains)
   */
  private String documentTypeNotcontains;
  /**
   * 类型 比较(startswith)
   */
  private String documentTypeStartswith;
  /**
   * 类型 比较(endswith)
   */
  private String documentTypeEndswith;
  /**
   * 类型 比较(isnull)
   */
  private Boolean documentTypeIsnull;
  /**
   * 类型 比较(isnotnull)
   */
  private Boolean documentTypeIsnotnull;

  /**
   * 类型(精确搜索)
   */
  private List<String> documentTypeInList;

  /**
   * 单据号(模糊搜索)
   */
  private String countnum;

  /**
   * 单据号 比较(eq)
   */
  private String countnumEq;
  /**
   * 单据号 比较(neq)
   */
  private String countnumNeq;
  /**
   * 单据号 比较(gt)
   */
  private String countnumGt;
  /**
   * 单据号 比较(gte)
   */
  private String countnumGte;
  /**
   * 单据号 比较(lt)
   */
  private String countnumLt;
  /**
   * 单据号 比较(lte)
   */
  private String countnumLte;
  /**
   * 单据号 比较(contains)
   */
  private String countnumContains;
  /**
   * 单据号 比较(notcontains)
   */
  private String countnumNotcontains;
  /**
   * 单据号 比较(startswith)
   */
  private String countnumStartswith;
  /**
   * 单据号 比较(endswith)
   */
  private String countnumEndswith;
  /**
   * 单据号 比较(isnull)
   */
  private Boolean countnumIsnull;
  /**
   * 单据号 比较(isnotnull)
   */
  private Boolean countnumIsnotnull;

  /**
   * 单据号(精确搜索)
   */
  private List<String> countnumInList;

  /**
   * 关联单据号(模糊搜索)
   */
  private String formNum;

  /**
   * 关联单据号 比较(eq)
   */
  private String formNumEq;
  /**
   * 关联单据号 比较(neq)
   */
  private String formNumNeq;
  /**
   * 关联单据号 比较(gt)
   */
  private String formNumGt;
  /**
   * 关联单据号 比较(gte)
   */
  private String formNumGte;
  /**
   * 关联单据号 比较(lt)
   */
  private String formNumLt;
  /**
   * 关联单据号 比较(lte)
   */
  private String formNumLte;
  /**
   * 关联单据号 比较(contains)
   */
  private String formNumContains;
  /**
   * 关联单据号 比较(notcontains)
   */
  private String formNumNotcontains;
  /**
   * 关联单据号 比较(startswith)
   */
  private String formNumStartswith;
  /**
   * 关联单据号 比较(endswith)
   */
  private String formNumEndswith;
  /**
   * 关联单据号 比较(isnull)
   */
  private Boolean formNumIsnull;
  /**
   * 关联单据号 比较(isnotnull)
   */
  private Boolean formNumIsnotnull;

  /**
   * 关联单据号(精确搜索)
   */
  private List<String> formNumInList;

  /**
   * 品名
   */
  private Long itemId;

  /**
   * 品名 比较(eq)
   */
  private Long itemIdEq;
  /**
   * 品名 比较(neq)
   */
  private Long itemIdNeq;
  /**
   * 品名 比较(gt)
   */
  private Long itemIdGt;
  /**
   * 品名 比较(gte)
   */
  private Long itemIdGte;
  /**
   * 品名 比较(lt)
   */
  private Long itemIdLt;
  /**
   * 品名 比较(lte)
   */
  private Long itemIdLte;
  /**
   * 品名 比较(contains)
   */
  private Long itemIdContains;
  /**
   * 品名 比较(notcontains)
   */
  private Long itemIdNotcontains;
  /**
   * 品名 比较(startswith)
   */
  private Long itemIdStartswith;
  /**
   * 品名 比较(endswith)
   */
  private Long itemIdEndswith;
  /**
   * 品名 比较(isnull)
   */
  private Boolean itemIdIsnull;
  /**
   * 品名 比较(isnotnull)
   */
  private Boolean itemIdIsnotnull;
  /**
   * 品名的品名 比较(eq)
   */
  private String itemIdNameEq;
  /**
   * 品名的品名 比较(neq)
   */
  private String itemIdNameNeq;
  /**
   * 品名的品名 比较(gt)
   */
  private String itemIdNameGt;
  /**
   * 品名的品名 比较(gte)
   */
  private String itemIdNameGte;
  /**
   * 品名的品名 比较(lt)
   */
  private String itemIdNameLt;
  /**
   * 品名的品名 比较(lte)
   */
  private String itemIdNameLte;
  /**
   * 品名的品名 比较(contains)
   */
  private String itemIdNameContains;
  /**
   * 品名的品名 比较(notcontains)
   */
  private String itemIdNameNotcontains;
  /**
   * 品名的品名 比较(startswith)
   */
  private String itemIdNameStartswith;
  /**
   * 品名的品名 比较(endswith)
   */
  private String itemIdNameEndswith;
  /**
   * 品名的品名 比较(isnull)
   */
  private Boolean itemIdNameIsnull;
  /**
   * 品名的品名 比较(isnotnull)
   */
  private Boolean itemIdNameIsnotnull;

  /**
   * 品名(范围搜索)
   */
  private List<Long> itemIdInList;

  /**
   * SKU(模糊搜索)
   */
  private String sku;

  /**
   * SKU 比较(eq)
   */
  private String skuEq;
  /**
   * SKU 比较(neq)
   */
  private String skuNeq;
  /**
   * SKU 比较(gt)
   */
  private String skuGt;
  /**
   * SKU 比较(gte)
   */
  private String skuGte;
  /**
   * SKU 比较(lt)
   */
  private String skuLt;
  /**
   * SKU 比较(lte)
   */
  private String skuLte;
  /**
   * SKU 比较(contains)
   */
  private String skuContains;
  /**
   * SKU 比较(notcontains)
   */
  private String skuNotcontains;
  /**
   * SKU 比较(startswith)
   */
  private String skuStartswith;
  /**
   * SKU 比较(endswith)
   */
  private String skuEndswith;
  /**
   * SKU 比较(isnull)
   */
  private Boolean skuIsnull;
  /**
   * SKU 比较(isnotnull)
   */
  private Boolean skuIsnotnull;

  /**
   * SKU(精确搜索)
   */
  private List<String> skuInList;

  /**
   * 店铺
   */
  private Long shopId;

  /**
   * 店铺 比较(eq)
   */
  private Long shopIdEq;
  /**
   * 店铺 比较(neq)
   */
  private Long shopIdNeq;
  /**
   * 店铺 比较(gt)
   */
  private Long shopIdGt;
  /**
   * 店铺 比较(gte)
   */
  private Long shopIdGte;
  /**
   * 店铺 比较(lt)
   */
  private Long shopIdLt;
  /**
   * 店铺 比较(lte)
   */
  private Long shopIdLte;
  /**
   * 店铺 比较(contains)
   */
  private Long shopIdContains;
  /**
   * 店铺 比较(notcontains)
   */
  private Long shopIdNotcontains;
  /**
   * 店铺 比较(startswith)
   */
  private Long shopIdStartswith;
  /**
   * 店铺 比较(endswith)
   */
  private Long shopIdEndswith;
  /**
   * 店铺 比较(isnull)
   */
  private Boolean shopIdIsnull;
  /**
   * 店铺 比较(isnotnull)
   */
  private Boolean shopIdIsnotnull;
  /**
   * 店铺的名称 比较(eq)
   */
  private String shopIdShopNameEq;
  /**
   * 店铺的名称 比较(neq)
   */
  private String shopIdShopNameNeq;
  /**
   * 店铺的名称 比较(gt)
   */
  private String shopIdShopNameGt;
  /**
   * 店铺的名称 比较(gte)
   */
  private String shopIdShopNameGte;
  /**
   * 店铺的名称 比较(lt)
   */
  private String shopIdShopNameLt;
  /**
   * 店铺的名称 比较(lte)
   */
  private String shopIdShopNameLte;
  /**
   * 店铺的名称 比较(contains)
   */
  private String shopIdShopNameContains;
  /**
   * 店铺的名称 比较(notcontains)
   */
  private String shopIdShopNameNotcontains;
  /**
   * 店铺的名称 比较(startswith)
   */
  private String shopIdShopNameStartswith;
  /**
   * 店铺的名称 比较(endswith)
   */
  private String shopIdShopNameEndswith;
  /**
   * 店铺的名称 比较(isnull)
   */
  private Boolean shopIdShopNameIsnull;
  /**
   * 店铺的名称 比较(isnotnull)
   */
  private Boolean shopIdShopNameIsnotnull;

  /**
   * 店铺(范围搜索)
   */
  private List<Long> shopIdInList;

  /**
   * FNSKU(模糊搜索)
   */
  private String fnSku;

  /**
   * FNSKU 比较(eq)
   */
  private String fnSkuEq;
  /**
   * FNSKU 比较(neq)
   */
  private String fnSkuNeq;
  /**
   * FNSKU 比较(gt)
   */
  private String fnSkuGt;
  /**
   * FNSKU 比较(gte)
   */
  private String fnSkuGte;
  /**
   * FNSKU 比较(lt)
   */
  private String fnSkuLt;
  /**
   * FNSKU 比较(lte)
   */
  private String fnSkuLte;
  /**
   * FNSKU 比较(contains)
   */
  private String fnSkuContains;
  /**
   * FNSKU 比较(notcontains)
   */
  private String fnSkuNotcontains;
  /**
   * FNSKU 比较(startswith)
   */
  private String fnSkuStartswith;
  /**
   * FNSKU 比较(endswith)
   */
  private String fnSkuEndswith;
  /**
   * FNSKU 比较(isnull)
   */
  private Boolean fnSkuIsnull;
  /**
   * FNSKU 比较(isnotnull)
   */
  private Boolean fnSkuIsnotnull;

  /**
   * FNSKU(精确搜索)
   */
  private List<String> fnSkuInList;

  /**
   * 产品类型(模糊搜索)
   */
  private String itemType;

  /**
   * 产品类型 比较(eq)
   */
  private String itemTypeEq;
  /**
   * 产品类型 比较(neq)
   */
  private String itemTypeNeq;
  /**
   * 产品类型 比较(gt)
   */
  private String itemTypeGt;
  /**
   * 产品类型 比较(gte)
   */
  private String itemTypeGte;
  /**
   * 产品类型 比较(lt)
   */
  private String itemTypeLt;
  /**
   * 产品类型 比较(lte)
   */
  private String itemTypeLte;
  /**
   * 产品类型 比较(contains)
   */
  private String itemTypeContains;
  /**
   * 产品类型 比较(notcontains)
   */
  private String itemTypeNotcontains;
  /**
   * 产品类型 比较(startswith)
   */
  private String itemTypeStartswith;
  /**
   * 产品类型 比较(endswith)
   */
  private String itemTypeEndswith;
  /**
   * 产品类型 比较(isnull)
   */
  private Boolean itemTypeIsnull;
  /**
   * 产品类型 比较(isnotnull)
   */
  private Boolean itemTypeIsnotnull;

  /**
   * 产品类型(精确搜索)
   */
  private List<String> itemTypeInList;

  /**
   * 仓库
   */
  private Long stockId;

  /**
   * 仓库 比较(eq)
   */
  private Long stockIdEq;
  /**
   * 仓库 比较(neq)
   */
  private Long stockIdNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long stockIdGt;
  /**
   * 仓库 比较(gte)
   */
  private Long stockIdGte;
  /**
   * 仓库 比较(lt)
   */
  private Long stockIdLt;
  /**
   * 仓库 比较(lte)
   */
  private Long stockIdLte;
  /**
   * 仓库 比较(contains)
   */
  private Long stockIdContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long stockIdNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long stockIdStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long stockIdEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean stockIdIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean stockIdIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String stockIdNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String stockIdNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String stockIdNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String stockIdNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String stockIdNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String stockIdNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String stockIdNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String stockIdNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String stockIdNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String stockIdNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean stockIdNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean stockIdNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> stockIdInList;

  /**
   * 可用量
   */
  private Long stockQty;

  /**
   * 最小可用量
   */
  private Long stockQtyMin;

  /**
   * 最大可用量
   */
  private Long stockQtyMax;

  /**
   * 可用量 比较(eq)
   */
  private Long stockQtyEq;
  /**
   * 可用量 比较(neq)
   */
  private Long stockQtyNeq;
  /**
   * 可用量 比较(gt)
   */
  private Long stockQtyGt;
  /**
   * 可用量 比较(gte)
   */
  private Long stockQtyGte;
  /**
   * 可用量 比较(lt)
   */
  private Long stockQtyLt;
  /**
   * 可用量 比较(lte)
   */
  private Long stockQtyLte;
  /**
   * 可用量 比较(contains)
   */
  private Long stockQtyContains;
  /**
   * 可用量 比较(notcontains)
   */
  private Long stockQtyNotcontains;
  /**
   * 可用量 比较(startswith)
   */
  private Long stockQtyStartswith;
  /**
   * 可用量 比较(endswith)
   */
  private Long stockQtyEndswith;
  /**
   * 可用量 比较(isnull)
   */
  private Boolean stockQtyIsnull;
  /**
   * 可用量 比较(isnotnull)
   */
  private Boolean stockQtyIsnotnull;

  /**
   * 次品量
   */
  private Long defectQty;

  /**
   * 最小次品量
   */
  private Long defectQtyMin;

  /**
   * 最大次品量
   */
  private Long defectQtyMax;

  /**
   * 次品量 比较(eq)
   */
  private Long defectQtyEq;
  /**
   * 次品量 比较(neq)
   */
  private Long defectQtyNeq;
  /**
   * 次品量 比较(gt)
   */
  private Long defectQtyGt;
  /**
   * 次品量 比较(gte)
   */
  private Long defectQtyGte;
  /**
   * 次品量 比较(lt)
   */
  private Long defectQtyLt;
  /**
   * 次品量 比较(lte)
   */
  private Long defectQtyLte;
  /**
   * 次品量 比较(contains)
   */
  private Long defectQtyContains;
  /**
   * 次品量 比较(notcontains)
   */
  private Long defectQtyNotcontains;
  /**
   * 次品量 比较(startswith)
   */
  private Long defectQtyStartswith;
  /**
   * 次品量 比较(endswith)
   */
  private Long defectQtyEndswith;
  /**
   * 次品量 比较(isnull)
   */
  private Boolean defectQtyIsnull;
  /**
   * 次品量 比较(isnotnull)
   */
  private Boolean defectQtyIsnotnull;

  /**
   * 待检待上架量
   */
  private java.math.BigDecimal inspectedQty;

  /**
   * 最小待检待上架量
   */
  private java.math.BigDecimal inspectedQtyMin;

  /**
   * 最大待检待上架量
   */
  private java.math.BigDecimal inspectedQtyMax;

  /**
   * 待检待上架量 比较(eq)
   */
  private java.math.BigDecimal inspectedQtyEq;
  /**
   * 待检待上架量 比较(neq)
   */
  private java.math.BigDecimal inspectedQtyNeq;
  /**
   * 待检待上架量 比较(gt)
   */
  private java.math.BigDecimal inspectedQtyGt;
  /**
   * 待检待上架量 比较(gte)
   */
  private java.math.BigDecimal inspectedQtyGte;
  /**
   * 待检待上架量 比较(lt)
   */
  private java.math.BigDecimal inspectedQtyLt;
  /**
   * 待检待上架量 比较(lte)
   */
  private java.math.BigDecimal inspectedQtyLte;
  /**
   * 待检待上架量 比较(contains)
   */
  private java.math.BigDecimal inspectedQtyContains;
  /**
   * 待检待上架量 比较(notcontains)
   */
  private java.math.BigDecimal inspectedQtyNotcontains;
  /**
   * 待检待上架量 比较(startswith)
   */
  private java.math.BigDecimal inspectedQtyStartswith;
  /**
   * 待检待上架量 比较(endswith)
   */
  private java.math.BigDecimal inspectedQtyEndswith;
  /**
   * 待检待上架量 比较(isnull)
   */
  private Boolean inspectedQtyIsnull;
  /**
   * 待检待上架量 比较(isnotnull)
   */
  private Boolean inspectedQtyIsnotnull;

  /**
   * 可用锁定量
   */
  private java.math.BigDecimal lockQty;

  /**
   * 最小可用锁定量
   */
  private java.math.BigDecimal lockQtyMin;

  /**
   * 最大可用锁定量
   */
  private java.math.BigDecimal lockQtyMax;

  /**
   * 可用锁定量 比较(eq)
   */
  private java.math.BigDecimal lockQtyEq;
  /**
   * 可用锁定量 比较(neq)
   */
  private java.math.BigDecimal lockQtyNeq;
  /**
   * 可用锁定量 比较(gt)
   */
  private java.math.BigDecimal lockQtyGt;
  /**
   * 可用锁定量 比较(gte)
   */
  private java.math.BigDecimal lockQtyGte;
  /**
   * 可用锁定量 比较(lt)
   */
  private java.math.BigDecimal lockQtyLt;
  /**
   * 可用锁定量 比较(lte)
   */
  private java.math.BigDecimal lockQtyLte;
  /**
   * 可用锁定量 比较(contains)
   */
  private java.math.BigDecimal lockQtyContains;
  /**
   * 可用锁定量 比较(notcontains)
   */
  private java.math.BigDecimal lockQtyNotcontains;
  /**
   * 可用锁定量 比较(startswith)
   */
  private java.math.BigDecimal lockQtyStartswith;
  /**
   * 可用锁定量 比较(endswith)
   */
  private java.math.BigDecimal lockQtyEndswith;
  /**
   * 可用锁定量 比较(isnull)
   */
  private Boolean lockQtyIsnull;
  /**
   * 可用锁定量 比较(isnotnull)
   */
  private Boolean lockQtyIsnotnull;

  /**
   * 次品锁定量
   */
  private java.math.BigDecimal rejectLockQty;

  /**
   * 最小次品锁定量
   */
  private java.math.BigDecimal rejectLockQtyMin;

  /**
   * 最大次品锁定量
   */
  private java.math.BigDecimal rejectLockQtyMax;

  /**
   * 次品锁定量 比较(eq)
   */
  private java.math.BigDecimal rejectLockQtyEq;
  /**
   * 次品锁定量 比较(neq)
   */
  private java.math.BigDecimal rejectLockQtyNeq;
  /**
   * 次品锁定量 比较(gt)
   */
  private java.math.BigDecimal rejectLockQtyGt;
  /**
   * 次品锁定量 比较(gte)
   */
  private java.math.BigDecimal rejectLockQtyGte;
  /**
   * 次品锁定量 比较(lt)
   */
  private java.math.BigDecimal rejectLockQtyLt;
  /**
   * 次品锁定量 比较(lte)
   */
  private java.math.BigDecimal rejectLockQtyLte;
  /**
   * 次品锁定量 比较(contains)
   */
  private java.math.BigDecimal rejectLockQtyContains;
  /**
   * 次品锁定量 比较(notcontains)
   */
  private java.math.BigDecimal rejectLockQtyNotcontains;
  /**
   * 次品锁定量 比较(startswith)
   */
  private java.math.BigDecimal rejectLockQtyStartswith;
  /**
   * 次品锁定量 比较(endswith)
   */
  private java.math.BigDecimal rejectLockQtyEndswith;
  /**
   * 次品锁定量 比较(isnull)
   */
  private Boolean rejectLockQtyIsnull;
  /**
   * 次品锁定量 比较(isnotnull)
   */
  private Boolean rejectLockQtyIsnotnull;

  /**
   * 可用在途量
   */
  private java.math.BigDecimal wayQty;

  /**
   * 最小可用在途量
   */
  private java.math.BigDecimal wayQtyMin;

  /**
   * 最大可用在途量
   */
  private java.math.BigDecimal wayQtyMax;

  /**
   * 可用在途量 比较(eq)
   */
  private java.math.BigDecimal wayQtyEq;
  /**
   * 可用在途量 比较(neq)
   */
  private java.math.BigDecimal wayQtyNeq;
  /**
   * 可用在途量 比较(gt)
   */
  private java.math.BigDecimal wayQtyGt;
  /**
   * 可用在途量 比较(gte)
   */
  private java.math.BigDecimal wayQtyGte;
  /**
   * 可用在途量 比较(lt)
   */
  private java.math.BigDecimal wayQtyLt;
  /**
   * 可用在途量 比较(lte)
   */
  private java.math.BigDecimal wayQtyLte;
  /**
   * 可用在途量 比较(contains)
   */
  private java.math.BigDecimal wayQtyContains;
  /**
   * 可用在途量 比较(notcontains)
   */
  private java.math.BigDecimal wayQtyNotcontains;
  /**
   * 可用在途量 比较(startswith)
   */
  private java.math.BigDecimal wayQtyStartswith;
  /**
   * 可用在途量 比较(endswith)
   */
  private java.math.BigDecimal wayQtyEndswith;
  /**
   * 可用在途量 比较(isnull)
   */
  private Boolean wayQtyIsnull;
  /**
   * 可用在途量 比较(isnotnull)
   */
  private Boolean wayQtyIsnotnull;

  /**
   * 次品在途量
   */
  private java.math.BigDecimal rejectWayQty;

  /**
   * 最小次品在途量
   */
  private java.math.BigDecimal rejectWayQtyMin;

  /**
   * 最大次品在途量
   */
  private java.math.BigDecimal rejectWayQtyMax;

  /**
   * 次品在途量 比较(eq)
   */
  private java.math.BigDecimal rejectWayQtyEq;
  /**
   * 次品在途量 比较(neq)
   */
  private java.math.BigDecimal rejectWayQtyNeq;
  /**
   * 次品在途量 比较(gt)
   */
  private java.math.BigDecimal rejectWayQtyGt;
  /**
   * 次品在途量 比较(gte)
   */
  private java.math.BigDecimal rejectWayQtyGte;
  /**
   * 次品在途量 比较(lt)
   */
  private java.math.BigDecimal rejectWayQtyLt;
  /**
   * 次品在途量 比较(lte)
   */
  private java.math.BigDecimal rejectWayQtyLte;
  /**
   * 次品在途量 比较(contains)
   */
  private java.math.BigDecimal rejectWayQtyContains;
  /**
   * 次品在途量 比较(notcontains)
   */
  private java.math.BigDecimal rejectWayQtyNotcontains;
  /**
   * 次品在途量 比较(startswith)
   */
  private java.math.BigDecimal rejectWayQtyStartswith;
  /**
   * 次品在途量 比较(endswith)
   */
  private java.math.BigDecimal rejectWayQtyEndswith;
  /**
   * 次品在途量 比较(isnull)
   */
  private Boolean rejectWayQtyIsnull;
  /**
   * 次品在途量 比较(isnotnull)
   */
  private Boolean rejectWayQtyIsnotnull;

  /**
   * 采购单价
   */
  private java.math.BigDecimal purchasePrice;

  /**
   * 最小采购单价
   */
  private java.math.BigDecimal purchasePriceMin;

  /**
   * 最大采购单价
   */
  private java.math.BigDecimal purchasePriceMax;

  /**
   * 采购单价 比较(eq)
   */
  private java.math.BigDecimal purchasePriceEq;
  /**
   * 采购单价 比较(neq)
   */
  private java.math.BigDecimal purchasePriceNeq;
  /**
   * 采购单价 比较(gt)
   */
  private java.math.BigDecimal purchasePriceGt;
  /**
   * 采购单价 比较(gte)
   */
  private java.math.BigDecimal purchasePriceGte;
  /**
   * 采购单价 比较(lt)
   */
  private java.math.BigDecimal purchasePriceLt;
  /**
   * 采购单价 比较(lte)
   */
  private java.math.BigDecimal purchasePriceLte;
  /**
   * 采购单价 比较(contains)
   */
  private java.math.BigDecimal purchasePriceContains;
  /**
   * 采购单价 比较(notcontains)
   */
  private java.math.BigDecimal purchasePriceNotcontains;
  /**
   * 采购单价 比较(startswith)
   */
  private java.math.BigDecimal purchasePriceStartswith;
  /**
   * 采购单价 比较(endswith)
   */
  private java.math.BigDecimal purchasePriceEndswith;
  /**
   * 采购单价 比较(isnull)
   */
  private Boolean purchasePriceIsnull;
  /**
   * 采购单价 比较(isnotnull)
   */
  private Boolean purchasePriceIsnotnull;

  /**
   * 单位费用
   */
  private java.math.BigDecimal unitCosts;

  /**
   * 最小单位费用
   */
  private java.math.BigDecimal unitCostsMin;

  /**
   * 最大单位费用
   */
  private java.math.BigDecimal unitCostsMax;

  /**
   * 单位费用 比较(eq)
   */
  private java.math.BigDecimal unitCostsEq;
  /**
   * 单位费用 比较(neq)
   */
  private java.math.BigDecimal unitCostsNeq;
  /**
   * 单位费用 比较(gt)
   */
  private java.math.BigDecimal unitCostsGt;
  /**
   * 单位费用 比较(gte)
   */
  private java.math.BigDecimal unitCostsGte;
  /**
   * 单位费用 比较(lt)
   */
  private java.math.BigDecimal unitCostsLt;
  /**
   * 单位费用 比较(lte)
   */
  private java.math.BigDecimal unitCostsLte;
  /**
   * 单位费用 比较(contains)
   */
  private java.math.BigDecimal unitCostsContains;
  /**
   * 单位费用 比较(notcontains)
   */
  private java.math.BigDecimal unitCostsNotcontains;
  /**
   * 单位费用 比较(startswith)
   */
  private java.math.BigDecimal unitCostsStartswith;
  /**
   * 单位费用 比较(endswith)
   */
  private java.math.BigDecimal unitCostsEndswith;
  /**
   * 单位费用 比较(isnull)
   */
  private Boolean unitCostsIsnull;
  /**
   * 单位费用 比较(isnotnull)
   */
  private Boolean unitCostsIsnotnull;

  /**
   * 单位头程
   */
  private java.math.BigDecimal unitHeadStroke;

  /**
   * 最小单位头程
   */
  private java.math.BigDecimal unitHeadStrokeMin;

  /**
   * 最大单位头程
   */
  private java.math.BigDecimal unitHeadStrokeMax;

  /**
   * 单位头程 比较(eq)
   */
  private java.math.BigDecimal unitHeadStrokeEq;
  /**
   * 单位头程 比较(neq)
   */
  private java.math.BigDecimal unitHeadStrokeNeq;
  /**
   * 单位头程 比较(gt)
   */
  private java.math.BigDecimal unitHeadStrokeGt;
  /**
   * 单位头程 比较(gte)
   */
  private java.math.BigDecimal unitHeadStrokeGte;
  /**
   * 单位头程 比较(lt)
   */
  private java.math.BigDecimal unitHeadStrokeLt;
  /**
   * 单位头程 比较(lte)
   */
  private java.math.BigDecimal unitHeadStrokeLte;
  /**
   * 单位头程 比较(contains)
   */
  private java.math.BigDecimal unitHeadStrokeContains;
  /**
   * 单位头程 比较(notcontains)
   */
  private java.math.BigDecimal unitHeadStrokeNotcontains;
  /**
   * 单位头程 比较(startswith)
   */
  private java.math.BigDecimal unitHeadStrokeStartswith;
  /**
   * 单位头程 比较(endswith)
   */
  private java.math.BigDecimal unitHeadStrokeEndswith;
  /**
   * 单位头程 比较(isnull)
   */
  private Boolean unitHeadStrokeIsnull;
  /**
   * 单位头程 比较(isnotnull)
   */
  private Boolean unitHeadStrokeIsnotnull;

  /**
   * 单位库存成本
   */
  private java.math.BigDecimal unitInventoryCost;

  /**
   * 最小单位库存成本
   */
  private java.math.BigDecimal unitInventoryCostMin;

  /**
   * 最大单位库存成本
   */
  private java.math.BigDecimal unitInventoryCostMax;

  /**
   * 单位库存成本 比较(eq)
   */
  private java.math.BigDecimal unitInventoryCostEq;
  /**
   * 单位库存成本 比较(neq)
   */
  private java.math.BigDecimal unitInventoryCostNeq;
  /**
   * 单位库存成本 比较(gt)
   */
  private java.math.BigDecimal unitInventoryCostGt;
  /**
   * 单位库存成本 比较(gte)
   */
  private java.math.BigDecimal unitInventoryCostGte;
  /**
   * 单位库存成本 比较(lt)
   */
  private java.math.BigDecimal unitInventoryCostLt;
  /**
   * 单位库存成本 比较(lte)
   */
  private java.math.BigDecimal unitInventoryCostLte;
  /**
   * 单位库存成本 比较(contains)
   */
  private java.math.BigDecimal unitInventoryCostContains;
  /**
   * 单位库存成本 比较(notcontains)
   */
  private java.math.BigDecimal unitInventoryCostNotcontains;
  /**
   * 单位库存成本 比较(startswith)
   */
  private java.math.BigDecimal unitInventoryCostStartswith;
  /**
   * 单位库存成本 比较(endswith)
   */
  private java.math.BigDecimal unitInventoryCostEndswith;
  /**
   * 单位库存成本 比较(isnull)
   */
  private Boolean unitInventoryCostIsnull;
  /**
   * 单位库存成本 比较(isnotnull)
   */
  private Boolean unitInventoryCostIsnotnull;

  /**
   * 货值
   */
  private java.math.BigDecimal goodsValue;

  /**
   * 最小货值
   */
  private java.math.BigDecimal goodsValueMin;

  /**
   * 最大货值
   */
  private java.math.BigDecimal goodsValueMax;

  /**
   * 货值 比较(eq)
   */
  private java.math.BigDecimal goodsValueEq;
  /**
   * 货值 比较(neq)
   */
  private java.math.BigDecimal goodsValueNeq;
  /**
   * 货值 比较(gt)
   */
  private java.math.BigDecimal goodsValueGt;
  /**
   * 货值 比较(gte)
   */
  private java.math.BigDecimal goodsValueGte;
  /**
   * 货值 比较(lt)
   */
  private java.math.BigDecimal goodsValueLt;
  /**
   * 货值 比较(lte)
   */
  private java.math.BigDecimal goodsValueLte;
  /**
   * 货值 比较(contains)
   */
  private java.math.BigDecimal goodsValueContains;
  /**
   * 货值 比较(notcontains)
   */
  private java.math.BigDecimal goodsValueNotcontains;
  /**
   * 货值 比较(startswith)
   */
  private java.math.BigDecimal goodsValueStartswith;
  /**
   * 货值 比较(endswith)
   */
  private java.math.BigDecimal goodsValueEndswith;
  /**
   * 货值 比较(isnull)
   */
  private Boolean goodsValueIsnull;
  /**
   * 货值 比较(isnotnull)
   */
  private Boolean goodsValueIsnotnull;

  /**
   * 费用
   */
  private java.math.BigDecimal expenses;

  /**
   * 最小费用
   */
  private java.math.BigDecimal expensesMin;

  /**
   * 最大费用
   */
  private java.math.BigDecimal expensesMax;

  /**
   * 费用 比较(eq)
   */
  private java.math.BigDecimal expensesEq;
  /**
   * 费用 比较(neq)
   */
  private java.math.BigDecimal expensesNeq;
  /**
   * 费用 比较(gt)
   */
  private java.math.BigDecimal expensesGt;
  /**
   * 费用 比较(gte)
   */
  private java.math.BigDecimal expensesGte;
  /**
   * 费用 比较(lt)
   */
  private java.math.BigDecimal expensesLt;
  /**
   * 费用 比较(lte)
   */
  private java.math.BigDecimal expensesLte;
  /**
   * 费用 比较(contains)
   */
  private java.math.BigDecimal expensesContains;
  /**
   * 费用 比较(notcontains)
   */
  private java.math.BigDecimal expensesNotcontains;
  /**
   * 费用 比较(startswith)
   */
  private java.math.BigDecimal expensesStartswith;
  /**
   * 费用 比较(endswith)
   */
  private java.math.BigDecimal expensesEndswith;
  /**
   * 费用 比较(isnull)
   */
  private Boolean expensesIsnull;
  /**
   * 费用 比较(isnotnull)
   */
  private Boolean expensesIsnotnull;

  /**
   * 头程
   */
  private java.math.BigDecimal headStroke;

  /**
   * 最小头程
   */
  private java.math.BigDecimal headStrokeMin;

  /**
   * 最大头程
   */
  private java.math.BigDecimal headStrokeMax;

  /**
   * 头程 比较(eq)
   */
  private java.math.BigDecimal headStrokeEq;
  /**
   * 头程 比较(neq)
   */
  private java.math.BigDecimal headStrokeNeq;
  /**
   * 头程 比较(gt)
   */
  private java.math.BigDecimal headStrokeGt;
  /**
   * 头程 比较(gte)
   */
  private java.math.BigDecimal headStrokeGte;
  /**
   * 头程 比较(lt)
   */
  private java.math.BigDecimal headStrokeLt;
  /**
   * 头程 比较(lte)
   */
  private java.math.BigDecimal headStrokeLte;
  /**
   * 头程 比较(contains)
   */
  private java.math.BigDecimal headStrokeContains;
  /**
   * 头程 比较(notcontains)
   */
  private java.math.BigDecimal headStrokeNotcontains;
  /**
   * 头程 比较(startswith)
   */
  private java.math.BigDecimal headStrokeStartswith;
  /**
   * 头程 比较(endswith)
   */
  private java.math.BigDecimal headStrokeEndswith;
  /**
   * 头程 比较(isnull)
   */
  private Boolean headStrokeIsnull;
  /**
   * 头程 比较(isnotnull)
   */
  private Boolean headStrokeIsnotnull;

  /**
   * 库存成本
   */
  private java.math.BigDecimal inventoryCost;

  /**
   * 最小库存成本
   */
  private java.math.BigDecimal inventoryCostMin;

  /**
   * 最大库存成本
   */
  private java.math.BigDecimal inventoryCostMax;

  /**
   * 库存成本 比较(eq)
   */
  private java.math.BigDecimal inventoryCostEq;
  /**
   * 库存成本 比较(neq)
   */
  private java.math.BigDecimal inventoryCostNeq;
  /**
   * 库存成本 比较(gt)
   */
  private java.math.BigDecimal inventoryCostGt;
  /**
   * 库存成本 比较(gte)
   */
  private java.math.BigDecimal inventoryCostGte;
  /**
   * 库存成本 比较(lt)
   */
  private java.math.BigDecimal inventoryCostLt;
  /**
   * 库存成本 比较(lte)
   */
  private java.math.BigDecimal inventoryCostLte;
  /**
   * 库存成本 比较(contains)
   */
  private java.math.BigDecimal inventoryCostContains;
  /**
   * 库存成本 比较(notcontains)
   */
  private java.math.BigDecimal inventoryCostNotcontains;
  /**
   * 库存成本 比较(startswith)
   */
  private java.math.BigDecimal inventoryCostStartswith;
  /**
   * 库存成本 比较(endswith)
   */
  private java.math.BigDecimal inventoryCostEndswith;
  /**
   * 库存成本 比较(isnull)
   */
  private Boolean inventoryCostIsnull;
  /**
   * 库存成本 比较(isnotnull)
   */
  private Boolean inventoryCostIsnotnull;

  /**
   * 操作人
   */
  private Long operator;

  /**
   * 最小操作人
   */
  private Long operatorMin;

  /**
   * 最大操作人
   */
  private Long operatorMax;

  /**
   * 操作人 比较(eq)
   */
  private Long operatorEq;
  /**
   * 操作人 比较(neq)
   */
  private Long operatorNeq;
  /**
   * 操作人 比较(gt)
   */
  private Long operatorGt;
  /**
   * 操作人 比较(gte)
   */
  private Long operatorGte;
  /**
   * 操作人 比较(lt)
   */
  private Long operatorLt;
  /**
   * 操作人 比较(lte)
   */
  private Long operatorLte;
  /**
   * 操作人 比较(contains)
   */
  private Long operatorContains;
  /**
   * 操作人 比较(notcontains)
   */
  private Long operatorNotcontains;
  /**
   * 操作人 比较(startswith)
   */
  private Long operatorStartswith;
  /**
   * 操作人 比较(endswith)
   */
  private Long operatorEndswith;
  /**
   * 操作人 比较(isnull)
   */
  private Boolean operatorIsnull;
  /**
   * 操作人 比较(isnotnull)
   */
  private Boolean operatorIsnotnull;

  /**
   * 项目内码
   */
  private Long projectId;

  /**
   * 最小项目内码
   */
  private Long projectIdMin;

  /**
   * 最大项目内码
   */
  private Long projectIdMax;

  /**
   * 项目内码 比较(eq)
   */
  private Long projectIdEq;
  /**
   * 项目内码 比较(neq)
   */
  private Long projectIdNeq;
  /**
   * 项目内码 比较(gt)
   */
  private Long projectIdGt;
  /**
   * 项目内码 比较(gte)
   */
  private Long projectIdGte;
  /**
   * 项目内码 比较(lt)
   */
  private Long projectIdLt;
  /**
   * 项目内码 比较(lte)
   */
  private Long projectIdLte;
  /**
   * 项目内码 比较(contains)
   */
  private Long projectIdContains;
  /**
   * 项目内码 比较(notcontains)
   */
  private Long projectIdNotcontains;
  /**
   * 项目内码 比较(startswith)
   */
  private Long projectIdStartswith;
  /**
   * 项目内码 比较(endswith)
   */
  private Long projectIdEndswith;
  /**
   * 项目内码 比较(isnull)
   */
  private Boolean projectIdIsnull;
  /**
   * 项目内码 比较(isnotnull)
   */
  private Boolean projectIdIsnotnull;

  /**
   * 备注(模糊搜索)
   */
  private String remark;

  /**
   * 备注 比较(eq)
   */
  private String remarkEq;
  /**
   * 备注 比较(neq)
   */
  private String remarkNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarkGt;
  /**
   * 备注 比较(gte)
   */
  private String remarkGte;
  /**
   * 备注 比较(lt)
   */
  private String remarkLt;
  /**
   * 备注 比较(lte)
   */
  private String remarkLte;
  /**
   * 备注 比较(contains)
   */
  private String remarkContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarkNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarkStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarkEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarkIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarkIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarkInList;

  /**
   * 次品结存量
   */
  private Long inventoryOfDefectiveGoods;

  /**
   * 最小次品结存量
   */
  private Long inventoryOfDefectiveGoodsMin;

  /**
   * 最大次品结存量
   */
  private Long inventoryOfDefectiveGoodsMax;

  /**
   * 次品结存量 比较(eq)
   */
  private Long inventoryOfDefectiveGoodsEq;
  /**
   * 次品结存量 比较(neq)
   */
  private Long inventoryOfDefectiveGoodsNeq;
  /**
   * 次品结存量 比较(gt)
   */
  private Long inventoryOfDefectiveGoodsGt;
  /**
   * 次品结存量 比较(gte)
   */
  private Long inventoryOfDefectiveGoodsGte;
  /**
   * 次品结存量 比较(lt)
   */
  private Long inventoryOfDefectiveGoodsLt;
  /**
   * 次品结存量 比较(lte)
   */
  private Long inventoryOfDefectiveGoodsLte;
  /**
   * 次品结存量 比较(contains)
   */
  private Long inventoryOfDefectiveGoodsContains;
  /**
   * 次品结存量 比较(notcontains)
   */
  private Long inventoryOfDefectiveGoodsNotcontains;
  /**
   * 次品结存量 比较(startswith)
   */
  private Long inventoryOfDefectiveGoodsStartswith;
  /**
   * 次品结存量 比较(endswith)
   */
  private Long inventoryOfDefectiveGoodsEndswith;
  /**
   * 次品结存量 比较(isnull)
   */
  private Boolean inventoryOfDefectiveGoodsIsnull;
  /**
   * 次品结存量 比较(isnotnull)
   */
  private Boolean inventoryOfDefectiveGoodsIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 次品锁定结存量
   */
  private Long lockStockGoods;

  /**
   * 最小次品锁定结存量
   */
  private Long lockStockGoodsMin;

  /**
   * 最大次品锁定结存量
   */
  private Long lockStockGoodsMax;

  /**
   * 次品锁定结存量 比较(eq)
   */
  private Long lockStockGoodsEq;
  /**
   * 次品锁定结存量 比较(neq)
   */
  private Long lockStockGoodsNeq;
  /**
   * 次品锁定结存量 比较(gt)
   */
  private Long lockStockGoodsGt;
  /**
   * 次品锁定结存量 比较(gte)
   */
  private Long lockStockGoodsGte;
  /**
   * 次品锁定结存量 比较(lt)
   */
  private Long lockStockGoodsLt;
  /**
   * 次品锁定结存量 比较(lte)
   */
  private Long lockStockGoodsLte;
  /**
   * 次品锁定结存量 比较(contains)
   */
  private Long lockStockGoodsContains;
  /**
   * 次品锁定结存量 比较(notcontains)
   */
  private Long lockStockGoodsNotcontains;
  /**
   * 次品锁定结存量 比较(startswith)
   */
  private Long lockStockGoodsStartswith;
  /**
   * 次品锁定结存量 比较(endswith)
   */
  private Long lockStockGoodsEndswith;
  /**
   * 次品锁定结存量 比较(isnull)
   */
  private Boolean lockStockGoodsIsnull;
  /**
   * 次品锁定结存量 比较(isnotnull)
   */
  private Boolean lockStockGoodsIsnotnull;

  /**
   * 可用锁定量
   */
  private Long locksAvailableAmount;

  /**
   * 最小可用锁定量
   */
  private Long locksAvailableAmountMin;

  /**
   * 最大可用锁定量
   */
  private Long locksAvailableAmountMax;

  /**
   * 可用锁定量 比较(eq)
   */
  private Long locksAvailableAmountEq;
  /**
   * 可用锁定量 比较(neq)
   */
  private Long locksAvailableAmountNeq;
  /**
   * 可用锁定量 比较(gt)
   */
  private Long locksAvailableAmountGt;
  /**
   * 可用锁定量 比较(gte)
   */
  private Long locksAvailableAmountGte;
  /**
   * 可用锁定量 比较(lt)
   */
  private Long locksAvailableAmountLt;
  /**
   * 可用锁定量 比较(lte)
   */
  private Long locksAvailableAmountLte;
  /**
   * 可用锁定量 比较(contains)
   */
  private Long locksAvailableAmountContains;
  /**
   * 可用锁定量 比较(notcontains)
   */
  private Long locksAvailableAmountNotcontains;
  /**
   * 可用锁定量 比较(startswith)
   */
  private Long locksAvailableAmountStartswith;
  /**
   * 可用锁定量 比较(endswith)
   */
  private Long locksAvailableAmountEndswith;
  /**
   * 可用锁定量 比较(isnull)
   */
  private Boolean locksAvailableAmountIsnull;
  /**
   * 可用锁定量 比较(isnotnull)
   */
  private Boolean locksAvailableAmountIsnotnull;

  /**
   * 可用锁定结存量
   */
  private Long numberOfAvailableLock;

  /**
   * 最小可用锁定结存量
   */
  private Long numberOfAvailableLockMin;

  /**
   * 最大可用锁定结存量
   */
  private Long numberOfAvailableLockMax;

  /**
   * 可用锁定结存量 比较(eq)
   */
  private Long numberOfAvailableLockEq;
  /**
   * 可用锁定结存量 比较(neq)
   */
  private Long numberOfAvailableLockNeq;
  /**
   * 可用锁定结存量 比较(gt)
   */
  private Long numberOfAvailableLockGt;
  /**
   * 可用锁定结存量 比较(gte)
   */
  private Long numberOfAvailableLockGte;
  /**
   * 可用锁定结存量 比较(lt)
   */
  private Long numberOfAvailableLockLt;
  /**
   * 可用锁定结存量 比较(lte)
   */
  private Long numberOfAvailableLockLte;
  /**
   * 可用锁定结存量 比较(contains)
   */
  private Long numberOfAvailableLockContains;
  /**
   * 可用锁定结存量 比较(notcontains)
   */
  private Long numberOfAvailableLockNotcontains;
  /**
   * 可用锁定结存量 比较(startswith)
   */
  private Long numberOfAvailableLockStartswith;
  /**
   * 可用锁定结存量 比较(endswith)
   */
  private Long numberOfAvailableLockEndswith;
  /**
   * 可用锁定结存量 比较(isnull)
   */
  private Boolean numberOfAvailableLockIsnull;
  /**
   * 可用锁定结存量 比较(isnotnull)
   */
  private Boolean numberOfAvailableLockIsnotnull;

  /**
   * 操作业务名称(模糊搜索)
   */
  private String operate;

  /**
   * 操作业务名称 比较(eq)
   */
  private String operateEq;
  /**
   * 操作业务名称 比较(neq)
   */
  private String operateNeq;
  /**
   * 操作业务名称 比较(gt)
   */
  private String operateGt;
  /**
   * 操作业务名称 比较(gte)
   */
  private String operateGte;
  /**
   * 操作业务名称 比较(lt)
   */
  private String operateLt;
  /**
   * 操作业务名称 比较(lte)
   */
  private String operateLte;
  /**
   * 操作业务名称 比较(contains)
   */
  private String operateContains;
  /**
   * 操作业务名称 比较(notcontains)
   */
  private String operateNotcontains;
  /**
   * 操作业务名称 比较(startswith)
   */
  private String operateStartswith;
  /**
   * 操作业务名称 比较(endswith)
   */
  private String operateEndswith;
  /**
   * 操作业务名称 比较(isnull)
   */
  private Boolean operateIsnull;
  /**
   * 操作业务名称 比较(isnotnull)
   */
  private Boolean operateIsnotnull;

  /**
   * 操作业务名称(精确搜索)
   */
  private List<String> operateInList;

  /**
   * 关联唯一操作键(模糊搜索)
   */
  private String operateKey;

  /**
   * 关联唯一操作键 比较(eq)
   */
  private String operateKeyEq;
  /**
   * 关联唯一操作键 比较(neq)
   */
  private String operateKeyNeq;
  /**
   * 关联唯一操作键 比较(gt)
   */
  private String operateKeyGt;
  /**
   * 关联唯一操作键 比较(gte)
   */
  private String operateKeyGte;
  /**
   * 关联唯一操作键 比较(lt)
   */
  private String operateKeyLt;
  /**
   * 关联唯一操作键 比较(lte)
   */
  private String operateKeyLte;
  /**
   * 关联唯一操作键 比较(contains)
   */
  private String operateKeyContains;
  /**
   * 关联唯一操作键 比较(notcontains)
   */
  private String operateKeyNotcontains;
  /**
   * 关联唯一操作键 比较(startswith)
   */
  private String operateKeyStartswith;
  /**
   * 关联唯一操作键 比较(endswith)
   */
  private String operateKeyEndswith;
  /**
   * 关联唯一操作键 比较(isnull)
   */
  private Boolean operateKeyIsnull;
  /**
   * 关联唯一操作键 比较(isnotnull)
   */
  private Boolean operateKeyIsnotnull;

  /**
   * 关联唯一操作键(精确搜索)
   */
  private List<String> operateKeyInList;

  /**
   * 所属库存明细
   */
  private Long parentInventoryDetails;

  /**
   * 最小所属库存明细
   */
  private Long parentInventoryDetailsMin;

  /**
   * 最大所属库存明细
   */
  private Long parentInventoryDetailsMax;

  /**
   * 所属库存明细 比较(eq)
   */
  private Long parentInventoryDetailsEq;
  /**
   * 所属库存明细 比较(neq)
   */
  private Long parentInventoryDetailsNeq;
  /**
   * 所属库存明细 比较(gt)
   */
  private Long parentInventoryDetailsGt;
  /**
   * 所属库存明细 比较(gte)
   */
  private Long parentInventoryDetailsGte;
  /**
   * 所属库存明细 比较(lt)
   */
  private Long parentInventoryDetailsLt;
  /**
   * 所属库存明细 比较(lte)
   */
  private Long parentInventoryDetailsLte;
  /**
   * 所属库存明细 比较(contains)
   */
  private Long parentInventoryDetailsContains;
  /**
   * 所属库存明细 比较(notcontains)
   */
  private Long parentInventoryDetailsNotcontains;
  /**
   * 所属库存明细 比较(startswith)
   */
  private Long parentInventoryDetailsStartswith;
  /**
   * 所属库存明细 比较(endswith)
   */
  private Long parentInventoryDetailsEndswith;
  /**
   * 所属库存明细 比较(isnull)
   */
  private Boolean parentInventoryDetailsIsnull;
  /**
   * 所属库存明细 比较(isnotnull)
   */
  private Boolean parentInventoryDetailsIsnotnull;

  /**
   * 待检待上架量
   */
  private Long inspected;

  /**
   * 最小待检待上架量
   */
  private Long inspectedMin;

  /**
   * 最大待检待上架量
   */
  private Long inspectedMax;

  /**
   * 待检待上架量 比较(eq)
   */
  private Long inspectedEq;
  /**
   * 待检待上架量 比较(neq)
   */
  private Long inspectedNeq;
  /**
   * 待检待上架量 比较(gt)
   */
  private Long inspectedGt;
  /**
   * 待检待上架量 比较(gte)
   */
  private Long inspectedGte;
  /**
   * 待检待上架量 比较(lt)
   */
  private Long inspectedLt;
  /**
   * 待检待上架量 比较(lte)
   */
  private Long inspectedLte;
  /**
   * 待检待上架量 比较(contains)
   */
  private Long inspectedContains;
  /**
   * 待检待上架量 比较(notcontains)
   */
  private Long inspectedNotcontains;
  /**
   * 待检待上架量 比较(startswith)
   */
  private Long inspectedStartswith;
  /**
   * 待检待上架量 比较(endswith)
   */
  private Long inspectedEndswith;
  /**
   * 待检待上架量 比较(isnull)
   */
  private Boolean inspectedIsnull;
  /**
   * 待检待上架量 比较(isnotnull)
   */
  private Boolean inspectedIsnotnull;

  /**
   * 未知
   */
  private java.math.BigDecimal rejectLockGty;

  /**
   * 最小未知
   */
  private java.math.BigDecimal rejectLockGtyMin;

  /**
   * 最大未知
   */
  private java.math.BigDecimal rejectLockGtyMax;

  /**
   * 未知 比较(eq)
   */
  private java.math.BigDecimal rejectLockGtyEq;
  /**
   * 未知 比较(neq)
   */
  private java.math.BigDecimal rejectLockGtyNeq;
  /**
   * 未知 比较(gt)
   */
  private java.math.BigDecimal rejectLockGtyGt;
  /**
   * 未知 比较(gte)
   */
  private java.math.BigDecimal rejectLockGtyGte;
  /**
   * 未知 比较(lt)
   */
  private java.math.BigDecimal rejectLockGtyLt;
  /**
   * 未知 比较(lte)
   */
  private java.math.BigDecimal rejectLockGtyLte;
  /**
   * 未知 比较(contains)
   */
  private java.math.BigDecimal rejectLockGtyContains;
  /**
   * 未知 比较(notcontains)
   */
  private java.math.BigDecimal rejectLockGtyNotcontains;
  /**
   * 未知 比较(startswith)
   */
  private java.math.BigDecimal rejectLockGtyStartswith;
  /**
   * 未知 比较(endswith)
   */
  private java.math.BigDecimal rejectLockGtyEndswith;
  /**
   * 未知 比较(isnull)
   */
  private Boolean rejectLockGtyIsnull;
  /**
   * 未知 比较(isnotnull)
   */
  private Boolean rejectLockGtyIsnotnull;

  /**
   * 库存金额
   */
  private java.math.BigDecimal stockAmount;

  /**
   * 最小库存金额
   */
  private java.math.BigDecimal stockAmountMin;

  /**
   * 最大库存金额
   */
  private java.math.BigDecimal stockAmountMax;

  /**
   * 库存金额 比较(eq)
   */
  private java.math.BigDecimal stockAmountEq;
  /**
   * 库存金额 比较(neq)
   */
  private java.math.BigDecimal stockAmountNeq;
  /**
   * 库存金额 比较(gt)
   */
  private java.math.BigDecimal stockAmountGt;
  /**
   * 库存金额 比较(gte)
   */
  private java.math.BigDecimal stockAmountGte;
  /**
   * 库存金额 比较(lt)
   */
  private java.math.BigDecimal stockAmountLt;
  /**
   * 库存金额 比较(lte)
   */
  private java.math.BigDecimal stockAmountLte;
  /**
   * 库存金额 比较(contains)
   */
  private java.math.BigDecimal stockAmountContains;
  /**
   * 库存金额 比较(notcontains)
   */
  private java.math.BigDecimal stockAmountNotcontains;
  /**
   * 库存金额 比较(startswith)
   */
  private java.math.BigDecimal stockAmountStartswith;
  /**
   * 库存金额 比较(endswith)
   */
  private java.math.BigDecimal stockAmountEndswith;
  /**
   * 库存金额 比较(isnull)
   */
  private Boolean stockAmountIsnull;
  /**
   * 库存金额 比较(isnotnull)
   */
  private Boolean stockAmountIsnotnull;

  /**
   * 暂存数量
   */
  private java.math.BigDecimal storageQty;

  /**
   * 最小暂存数量
   */
  private java.math.BigDecimal storageQtyMin;

  /**
   * 最大暂存数量
   */
  private java.math.BigDecimal storageQtyMax;

  /**
   * 暂存数量 比较(eq)
   */
  private java.math.BigDecimal storageQtyEq;
  /**
   * 暂存数量 比较(neq)
   */
  private java.math.BigDecimal storageQtyNeq;
  /**
   * 暂存数量 比较(gt)
   */
  private java.math.BigDecimal storageQtyGt;
  /**
   * 暂存数量 比较(gte)
   */
  private java.math.BigDecimal storageQtyGte;
  /**
   * 暂存数量 比较(lt)
   */
  private java.math.BigDecimal storageQtyLt;
  /**
   * 暂存数量 比较(lte)
   */
  private java.math.BigDecimal storageQtyLte;
  /**
   * 暂存数量 比较(contains)
   */
  private java.math.BigDecimal storageQtyContains;
  /**
   * 暂存数量 比较(notcontains)
   */
  private java.math.BigDecimal storageQtyNotcontains;
  /**
   * 暂存数量 比较(startswith)
   */
  private java.math.BigDecimal storageQtyStartswith;
  /**
   * 暂存数量 比较(endswith)
   */
  private java.math.BigDecimal storageQtyEndswith;
  /**
   * 暂存数量 比较(isnull)
   */
  private Boolean storageQtyIsnull;
  /**
   * 暂存数量 比较(isnotnull)
   */
  private Boolean storageQtyIsnotnull;

  /**
   * 变动目标类型(模糊搜索)
   */
  private String toType;

  /**
   * 变动目标类型 比较(eq)
   */
  private String toTypeEq;
  /**
   * 变动目标类型 比较(neq)
   */
  private String toTypeNeq;
  /**
   * 变动目标类型 比较(gt)
   */
  private String toTypeGt;
  /**
   * 变动目标类型 比较(gte)
   */
  private String toTypeGte;
  /**
   * 变动目标类型 比较(lt)
   */
  private String toTypeLt;
  /**
   * 变动目标类型 比较(lte)
   */
  private String toTypeLte;
  /**
   * 变动目标类型 比较(contains)
   */
  private String toTypeContains;
  /**
   * 变动目标类型 比较(notcontains)
   */
  private String toTypeNotcontains;
  /**
   * 变动目标类型 比较(startswith)
   */
  private String toTypeStartswith;
  /**
   * 变动目标类型 比较(endswith)
   */
  private String toTypeEndswith;
  /**
   * 变动目标类型 比较(isnull)
   */
  private Boolean toTypeIsnull;
  /**
   * 变动目标类型 比较(isnotnull)
   */
  private Boolean toTypeIsnotnull;

  /**
   * 变动目标类型(精确搜索)
   */
  private List<String> toTypeInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 可用在途量
   */
  private Long availableCapacityInTransit;

  /**
   * 最小可用在途量
   */
  private Long availableCapacityInTransitMin;

  /**
   * 最大可用在途量
   */
  private Long availableCapacityInTransitMax;

  /**
   * 可用在途量 比较(eq)
   */
  private Long availableCapacityInTransitEq;
  /**
   * 可用在途量 比较(neq)
   */
  private Long availableCapacityInTransitNeq;
  /**
   * 可用在途量 比较(gt)
   */
  private Long availableCapacityInTransitGt;
  /**
   * 可用在途量 比较(gte)
   */
  private Long availableCapacityInTransitGte;
  /**
   * 可用在途量 比较(lt)
   */
  private Long availableCapacityInTransitLt;
  /**
   * 可用在途量 比较(lte)
   */
  private Long availableCapacityInTransitLte;
  /**
   * 可用在途量 比较(contains)
   */
  private Long availableCapacityInTransitContains;
  /**
   * 可用在途量 比较(notcontains)
   */
  private Long availableCapacityInTransitNotcontains;
  /**
   * 可用在途量 比较(startswith)
   */
  private Long availableCapacityInTransitStartswith;
  /**
   * 可用在途量 比较(endswith)
   */
  private Long availableCapacityInTransitEndswith;
  /**
   * 可用在途量 比较(isnull)
   */
  private Boolean availableCapacityInTransitIsnull;
  /**
   * 可用在途量 比较(isnotnull)
   */
  private Boolean availableCapacityInTransitIsnotnull;

  /**
   * 可用结存量
   */
  private Long availableInventory;

  /**
   * 最小可用结存量
   */
  private Long availableInventoryMin;

  /**
   * 最大可用结存量
   */
  private Long availableInventoryMax;

  /**
   * 可用结存量 比较(eq)
   */
  private Long availableInventoryEq;
  /**
   * 可用结存量 比较(neq)
   */
  private Long availableInventoryNeq;
  /**
   * 可用结存量 比较(gt)
   */
  private Long availableInventoryGt;
  /**
   * 可用结存量 比较(gte)
   */
  private Long availableInventoryGte;
  /**
   * 可用结存量 比较(lt)
   */
  private Long availableInventoryLt;
  /**
   * 可用结存量 比较(lte)
   */
  private Long availableInventoryLte;
  /**
   * 可用结存量 比较(contains)
   */
  private Long availableInventoryContains;
  /**
   * 可用结存量 比较(notcontains)
   */
  private Long availableInventoryNotcontains;
  /**
   * 可用结存量 比较(startswith)
   */
  private Long availableInventoryStartswith;
  /**
   * 可用结存量 比较(endswith)
   */
  private Long availableInventoryEndswith;
  /**
   * 可用结存量 比较(isnull)
   */
  private Boolean availableInventoryIsnull;
  /**
   * 可用结存量 比较(isnotnull)
   */
  private Boolean availableInventoryIsnotnull;

  /**
   * 可用在途结存量
   */
  private Long availableTransitInventory;

  /**
   * 最小可用在途结存量
   */
  private Long availableTransitInventoryMin;

  /**
   * 最大可用在途结存量
   */
  private Long availableTransitInventoryMax;

  /**
   * 可用在途结存量 比较(eq)
   */
  private Long availableTransitInventoryEq;
  /**
   * 可用在途结存量 比较(neq)
   */
  private Long availableTransitInventoryNeq;
  /**
   * 可用在途结存量 比较(gt)
   */
  private Long availableTransitInventoryGt;
  /**
   * 可用在途结存量 比较(gte)
   */
  private Long availableTransitInventoryGte;
  /**
   * 可用在途结存量 比较(lt)
   */
  private Long availableTransitInventoryLt;
  /**
   * 可用在途结存量 比较(lte)
   */
  private Long availableTransitInventoryLte;
  /**
   * 可用在途结存量 比较(contains)
   */
  private Long availableTransitInventoryContains;
  /**
   * 可用在途结存量 比较(notcontains)
   */
  private Long availableTransitInventoryNotcontains;
  /**
   * 可用在途结存量 比较(startswith)
   */
  private Long availableTransitInventoryStartswith;
  /**
   * 可用在途结存量 比较(endswith)
   */
  private Long availableTransitInventoryEndswith;
  /**
   * 可用在途结存量 比较(isnull)
   */
  private Boolean availableTransitInventoryIsnull;
  /**
   * 可用在途结存量 比较(isnotnull)
   */
  private Boolean availableTransitInventoryIsnotnull;

  /**
   * 批号
   */
  private Long batchNo;

  /**
   * 最小批号
   */
  private Long batchNoMin;

  /**
   * 最大批号
   */
  private Long batchNoMax;

  /**
   * 批号 比较(eq)
   */
  private Long batchNoEq;
  /**
   * 批号 比较(neq)
   */
  private Long batchNoNeq;
  /**
   * 批号 比较(gt)
   */
  private Long batchNoGt;
  /**
   * 批号 比较(gte)
   */
  private Long batchNoGte;
  /**
   * 批号 比较(lt)
   */
  private Long batchNoLt;
  /**
   * 批号 比较(lte)
   */
  private Long batchNoLte;
  /**
   * 批号 比较(contains)
   */
  private Long batchNoContains;
  /**
   * 批号 比较(notcontains)
   */
  private Long batchNoNotcontains;
  /**
   * 批号 比较(startswith)
   */
  private Long batchNoStartswith;
  /**
   * 批号 比较(endswith)
   */
  private Long batchNoEndswith;
  /**
   * 批号 比较(isnull)
   */
  private Boolean batchNoIsnull;
  /**
   * 批号 比较(isnotnull)
   */
  private Boolean batchNoIsnotnull;

  /**
   * 最早业务时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date businessTimeStart;

  /**
   * 最晚业务时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date businessTimeEnd;

  /**
   * 业务时间 比较(eq)
   */
  private Date businessTimeEq;
  /**
   * 业务时间 比较(neq)
   */
  private Date businessTimeNeq;
  /**
   * 业务时间 比较(gt)
   */
  private Date businessTimeGt;
  /**
   * 业务时间 比较(gte)
   */
  private Date businessTimeGte;
  /**
   * 业务时间 比较(lt)
   */
  private Date businessTimeLt;
  /**
   * 业务时间 比较(lte)
   */
  private Date businessTimeLte;
  /**
   * 业务时间 比较(contains)
   */
  private Date businessTimeContains;
  /**
   * 业务时间 比较(notcontains)
   */
  private Date businessTimeNotcontains;
  /**
   * 业务时间 比较(startswith)
   */
  private Date businessTimeStartswith;
  /**
   * 业务时间 比较(endswith)
   */
  private Date businessTimeEndswith;
  /**
   * 业务时间 比较(isnull)
   */
  private Boolean businessTimeIsnull;
  /**
   * 业务时间 比较(isnotnull)
   */
  private Boolean businessTimeIsnotnull;

  /**
   * 变动残次库存
   */
  private java.math.BigDecimal changeDefectQty;

  /**
   * 最小变动残次库存
   */
  private java.math.BigDecimal changeDefectQtyMin;

  /**
   * 最大变动残次库存
   */
  private java.math.BigDecimal changeDefectQtyMax;

  /**
   * 变动残次库存 比较(eq)
   */
  private java.math.BigDecimal changeDefectQtyEq;
  /**
   * 变动残次库存 比较(neq)
   */
  private java.math.BigDecimal changeDefectQtyNeq;
  /**
   * 变动残次库存 比较(gt)
   */
  private java.math.BigDecimal changeDefectQtyGt;
  /**
   * 变动残次库存 比较(gte)
   */
  private java.math.BigDecimal changeDefectQtyGte;
  /**
   * 变动残次库存 比较(lt)
   */
  private java.math.BigDecimal changeDefectQtyLt;
  /**
   * 变动残次库存 比较(lte)
   */
  private java.math.BigDecimal changeDefectQtyLte;
  /**
   * 变动残次库存 比较(contains)
   */
  private java.math.BigDecimal changeDefectQtyContains;
  /**
   * 变动残次库存 比较(notcontains)
   */
  private java.math.BigDecimal changeDefectQtyNotcontains;
  /**
   * 变动残次库存 比较(startswith)
   */
  private java.math.BigDecimal changeDefectQtyStartswith;
  /**
   * 变动残次库存 比较(endswith)
   */
  private java.math.BigDecimal changeDefectQtyEndswith;
  /**
   * 变动残次库存 比较(isnull)
   */
  private Boolean changeDefectQtyIsnull;
  /**
   * 变动残次库存 比较(isnotnull)
   */
  private Boolean changeDefectQtyIsnotnull;

  /**
   * 变动陈列库存
   */
  private java.math.BigDecimal changeDisplayQty;

  /**
   * 最小变动陈列库存
   */
  private java.math.BigDecimal changeDisplayQtyMin;

  /**
   * 最大变动陈列库存
   */
  private java.math.BigDecimal changeDisplayQtyMax;

  /**
   * 变动陈列库存 比较(eq)
   */
  private java.math.BigDecimal changeDisplayQtyEq;
  /**
   * 变动陈列库存 比较(neq)
   */
  private java.math.BigDecimal changeDisplayQtyNeq;
  /**
   * 变动陈列库存 比较(gt)
   */
  private java.math.BigDecimal changeDisplayQtyGt;
  /**
   * 变动陈列库存 比较(gte)
   */
  private java.math.BigDecimal changeDisplayQtyGte;
  /**
   * 变动陈列库存 比较(lt)
   */
  private java.math.BigDecimal changeDisplayQtyLt;
  /**
   * 变动陈列库存 比较(lte)
   */
  private java.math.BigDecimal changeDisplayQtyLte;
  /**
   * 变动陈列库存 比较(contains)
   */
  private java.math.BigDecimal changeDisplayQtyContains;
  /**
   * 变动陈列库存 比较(notcontains)
   */
  private java.math.BigDecimal changeDisplayQtyNotcontains;
  /**
   * 变动陈列库存 比较(startswith)
   */
  private java.math.BigDecimal changeDisplayQtyStartswith;
  /**
   * 变动陈列库存 比较(endswith)
   */
  private java.math.BigDecimal changeDisplayQtyEndswith;
  /**
   * 变动陈列库存 比较(isnull)
   */
  private Boolean changeDisplayQtyIsnull;
  /**
   * 变动陈列库存 比较(isnotnull)
   */
  private Boolean changeDisplayQtyIsnotnull;

  /**
   * 待检数量变更
   */
  private java.math.BigDecimal changeInspectedQty;

  /**
   * 最小待检数量变更
   */
  private java.math.BigDecimal changeInspectedQtyMin;

  /**
   * 最大待检数量变更
   */
  private java.math.BigDecimal changeInspectedQtyMax;

  /**
   * 待检数量变更 比较(eq)
   */
  private java.math.BigDecimal changeInspectedQtyEq;
  /**
   * 待检数量变更 比较(neq)
   */
  private java.math.BigDecimal changeInspectedQtyNeq;
  /**
   * 待检数量变更 比较(gt)
   */
  private java.math.BigDecimal changeInspectedQtyGt;
  /**
   * 待检数量变更 比较(gte)
   */
  private java.math.BigDecimal changeInspectedQtyGte;
  /**
   * 待检数量变更 比较(lt)
   */
  private java.math.BigDecimal changeInspectedQtyLt;
  /**
   * 待检数量变更 比较(lte)
   */
  private java.math.BigDecimal changeInspectedQtyLte;
  /**
   * 待检数量变更 比较(contains)
   */
  private java.math.BigDecimal changeInspectedQtyContains;
  /**
   * 待检数量变更 比较(notcontains)
   */
  private java.math.BigDecimal changeInspectedQtyNotcontains;
  /**
   * 待检数量变更 比较(startswith)
   */
  private java.math.BigDecimal changeInspectedQtyStartswith;
  /**
   * 待检数量变更 比较(endswith)
   */
  private java.math.BigDecimal changeInspectedQtyEndswith;
  /**
   * 待检数量变更 比较(isnull)
   */
  private Boolean changeInspectedQtyIsnull;
  /**
   * 待检数量变更 比较(isnotnull)
   */
  private Boolean changeInspectedQtyIsnotnull;

  /**
   * 变动锁库库存
   */
  private java.math.BigDecimal changeLockQty;

  /**
   * 最小变动锁库库存
   */
  private java.math.BigDecimal changeLockQtyMin;

  /**
   * 最大变动锁库库存
   */
  private java.math.BigDecimal changeLockQtyMax;

  /**
   * 变动锁库库存 比较(eq)
   */
  private java.math.BigDecimal changeLockQtyEq;
  /**
   * 变动锁库库存 比较(neq)
   */
  private java.math.BigDecimal changeLockQtyNeq;
  /**
   * 变动锁库库存 比较(gt)
   */
  private java.math.BigDecimal changeLockQtyGt;
  /**
   * 变动锁库库存 比较(gte)
   */
  private java.math.BigDecimal changeLockQtyGte;
  /**
   * 变动锁库库存 比较(lt)
   */
  private java.math.BigDecimal changeLockQtyLt;
  /**
   * 变动锁库库存 比较(lte)
   */
  private java.math.BigDecimal changeLockQtyLte;
  /**
   * 变动锁库库存 比较(contains)
   */
  private java.math.BigDecimal changeLockQtyContains;
  /**
   * 变动锁库库存 比较(notcontains)
   */
  private java.math.BigDecimal changeLockQtyNotcontains;
  /**
   * 变动锁库库存 比较(startswith)
   */
  private java.math.BigDecimal changeLockQtyStartswith;
  /**
   * 变动锁库库存 比较(endswith)
   */
  private java.math.BigDecimal changeLockQtyEndswith;
  /**
   * 变动锁库库存 比较(isnull)
   */
  private Boolean changeLockQtyIsnull;
  /**
   * 变动锁库库存 比较(isnotnull)
   */
  private Boolean changeLockQtyIsnotnull;

  /**
   * 次品锁定变更数量
   */
  private java.math.BigDecimal changeRejectLockQty;

  /**
   * 最小次品锁定变更数量
   */
  private java.math.BigDecimal changeRejectLockQtyMin;

  /**
   * 最大次品锁定变更数量
   */
  private java.math.BigDecimal changeRejectLockQtyMax;

  /**
   * 次品锁定变更数量 比较(eq)
   */
  private java.math.BigDecimal changeRejectLockQtyEq;
  /**
   * 次品锁定变更数量 比较(neq)
   */
  private java.math.BigDecimal changeRejectLockQtyNeq;
  /**
   * 次品锁定变更数量 比较(gt)
   */
  private java.math.BigDecimal changeRejectLockQtyGt;
  /**
   * 次品锁定变更数量 比较(gte)
   */
  private java.math.BigDecimal changeRejectLockQtyGte;
  /**
   * 次品锁定变更数量 比较(lt)
   */
  private java.math.BigDecimal changeRejectLockQtyLt;
  /**
   * 次品锁定变更数量 比较(lte)
   */
  private java.math.BigDecimal changeRejectLockQtyLte;
  /**
   * 次品锁定变更数量 比较(contains)
   */
  private java.math.BigDecimal changeRejectLockQtyContains;
  /**
   * 次品锁定变更数量 比较(notcontains)
   */
  private java.math.BigDecimal changeRejectLockQtyNotcontains;
  /**
   * 次品锁定变更数量 比较(startswith)
   */
  private java.math.BigDecimal changeRejectLockQtyStartswith;
  /**
   * 次品锁定变更数量 比较(endswith)
   */
  private java.math.BigDecimal changeRejectLockQtyEndswith;
  /**
   * 次品锁定变更数量 比较(isnull)
   */
  private Boolean changeRejectLockQtyIsnull;
  /**
   * 次品锁定变更数量 比较(isnotnull)
   */
  private Boolean changeRejectLockQtyIsnotnull;

  /**
   * 次品在途数量变更
   */
  private java.math.BigDecimal changeRejectWayQty;

  /**
   * 最小次品在途数量变更
   */
  private java.math.BigDecimal changeRejectWayQtyMin;

  /**
   * 最大次品在途数量变更
   */
  private java.math.BigDecimal changeRejectWayQtyMax;

  /**
   * 次品在途数量变更 比较(eq)
   */
  private java.math.BigDecimal changeRejectWayQtyEq;
  /**
   * 次品在途数量变更 比较(neq)
   */
  private java.math.BigDecimal changeRejectWayQtyNeq;
  /**
   * 次品在途数量变更 比较(gt)
   */
  private java.math.BigDecimal changeRejectWayQtyGt;
  /**
   * 次品在途数量变更 比较(gte)
   */
  private java.math.BigDecimal changeRejectWayQtyGte;
  /**
   * 次品在途数量变更 比较(lt)
   */
  private java.math.BigDecimal changeRejectWayQtyLt;
  /**
   * 次品在途数量变更 比较(lte)
   */
  private java.math.BigDecimal changeRejectWayQtyLte;
  /**
   * 次品在途数量变更 比较(contains)
   */
  private java.math.BigDecimal changeRejectWayQtyContains;
  /**
   * 次品在途数量变更 比较(notcontains)
   */
  private java.math.BigDecimal changeRejectWayQtyNotcontains;
  /**
   * 次品在途数量变更 比较(startswith)
   */
  private java.math.BigDecimal changeRejectWayQtyStartswith;
  /**
   * 次品在途数量变更 比较(endswith)
   */
  private java.math.BigDecimal changeRejectWayQtyEndswith;
  /**
   * 次品在途数量变更 比较(isnull)
   */
  private Boolean changeRejectWayQtyIsnull;
  /**
   * 次品在途数量变更 比较(isnotnull)
   */
  private Boolean changeRejectWayQtyIsnotnull;

  /**
   * 变动库存
   */
  private java.math.BigDecimal changeStockQty;

  /**
   * 最小变动库存
   */
  private java.math.BigDecimal changeStockQtyMin;

  /**
   * 最大变动库存
   */
  private java.math.BigDecimal changeStockQtyMax;

  /**
   * 变动库存 比较(eq)
   */
  private java.math.BigDecimal changeStockQtyEq;
  /**
   * 变动库存 比较(neq)
   */
  private java.math.BigDecimal changeStockQtyNeq;
  /**
   * 变动库存 比较(gt)
   */
  private java.math.BigDecimal changeStockQtyGt;
  /**
   * 变动库存 比较(gte)
   */
  private java.math.BigDecimal changeStockQtyGte;
  /**
   * 变动库存 比较(lt)
   */
  private java.math.BigDecimal changeStockQtyLt;
  /**
   * 变动库存 比较(lte)
   */
  private java.math.BigDecimal changeStockQtyLte;
  /**
   * 变动库存 比较(contains)
   */
  private java.math.BigDecimal changeStockQtyContains;
  /**
   * 变动库存 比较(notcontains)
   */
  private java.math.BigDecimal changeStockQtyNotcontains;
  /**
   * 变动库存 比较(startswith)
   */
  private java.math.BigDecimal changeStockQtyStartswith;
  /**
   * 变动库存 比较(endswith)
   */
  private java.math.BigDecimal changeStockQtyEndswith;
  /**
   * 变动库存 比较(isnull)
   */
  private Boolean changeStockQtyIsnull;
  /**
   * 变动库存 比较(isnotnull)
   */
  private Boolean changeStockQtyIsnotnull;

  /**
   * 暂存数量变更
   */
  private java.math.BigDecimal changeStorageQty;

  /**
   * 最小暂存数量变更
   */
  private java.math.BigDecimal changeStorageQtyMin;

  /**
   * 最大暂存数量变更
   */
  private java.math.BigDecimal changeStorageQtyMax;

  /**
   * 暂存数量变更 比较(eq)
   */
  private java.math.BigDecimal changeStorageQtyEq;
  /**
   * 暂存数量变更 比较(neq)
   */
  private java.math.BigDecimal changeStorageQtyNeq;
  /**
   * 暂存数量变更 比较(gt)
   */
  private java.math.BigDecimal changeStorageQtyGt;
  /**
   * 暂存数量变更 比较(gte)
   */
  private java.math.BigDecimal changeStorageQtyGte;
  /**
   * 暂存数量变更 比较(lt)
   */
  private java.math.BigDecimal changeStorageQtyLt;
  /**
   * 暂存数量变更 比较(lte)
   */
  private java.math.BigDecimal changeStorageQtyLte;
  /**
   * 暂存数量变更 比较(contains)
   */
  private java.math.BigDecimal changeStorageQtyContains;
  /**
   * 暂存数量变更 比较(notcontains)
   */
  private java.math.BigDecimal changeStorageQtyNotcontains;
  /**
   * 暂存数量变更 比较(startswith)
   */
  private java.math.BigDecimal changeStorageQtyStartswith;
  /**
   * 暂存数量变更 比较(endswith)
   */
  private java.math.BigDecimal changeStorageQtyEndswith;
  /**
   * 暂存数量变更 比较(isnull)
   */
  private Boolean changeStorageQtyIsnull;
  /**
   * 暂存数量变更 比较(isnotnull)
   */
  private Boolean changeStorageQtyIsnotnull;

  /**
   * 变动类型(模糊搜索)
   */
  private String changeType;

  /**
   * 变动类型 比较(eq)
   */
  private String changeTypeEq;
  /**
   * 变动类型 比较(neq)
   */
  private String changeTypeNeq;
  /**
   * 变动类型 比较(gt)
   */
  private String changeTypeGt;
  /**
   * 变动类型 比较(gte)
   */
  private String changeTypeGte;
  /**
   * 变动类型 比较(lt)
   */
  private String changeTypeLt;
  /**
   * 变动类型 比较(lte)
   */
  private String changeTypeLte;
  /**
   * 变动类型 比较(contains)
   */
  private String changeTypeContains;
  /**
   * 变动类型 比较(notcontains)
   */
  private String changeTypeNotcontains;
  /**
   * 变动类型 比较(startswith)
   */
  private String changeTypeStartswith;
  /**
   * 变动类型 比较(endswith)
   */
  private String changeTypeEndswith;
  /**
   * 变动类型 比较(isnull)
   */
  private Boolean changeTypeIsnull;
  /**
   * 变动类型 比较(isnotnull)
   */
  private Boolean changeTypeIsnotnull;

  /**
   * 变动类型(精确搜索)
   */
  private List<String> changeTypeInList;

  /**
   * 待检待上架结存量
   */
  private Long checkedAndSettled;

  /**
   * 最小待检待上架结存量
   */
  private Long checkedAndSettledMin;

  /**
   * 最大待检待上架结存量
   */
  private Long checkedAndSettledMax;

  /**
   * 待检待上架结存量 比较(eq)
   */
  private Long checkedAndSettledEq;
  /**
   * 待检待上架结存量 比较(neq)
   */
  private Long checkedAndSettledNeq;
  /**
   * 待检待上架结存量 比较(gt)
   */
  private Long checkedAndSettledGt;
  /**
   * 待检待上架结存量 比较(gte)
   */
  private Long checkedAndSettledGte;
  /**
   * 待检待上架结存量 比较(lt)
   */
  private Long checkedAndSettledLt;
  /**
   * 待检待上架结存量 比较(lte)
   */
  private Long checkedAndSettledLte;
  /**
   * 待检待上架结存量 比较(contains)
   */
  private Long checkedAndSettledContains;
  /**
   * 待检待上架结存量 比较(notcontains)
   */
  private Long checkedAndSettledNotcontains;
  /**
   * 待检待上架结存量 比较(startswith)
   */
  private Long checkedAndSettledStartswith;
  /**
   * 待检待上架结存量 比较(endswith)
   */
  private Long checkedAndSettledEndswith;
  /**
   * 待检待上架结存量 比较(isnull)
   */
  private Boolean checkedAndSettledIsnull;
  /**
   * 待检待上架结存量 比较(isnotnull)
   */
  private Boolean checkedAndSettledIsnotnull;

  /**
   * 辅助数量
   */
  private java.math.BigDecimal auxQty;

  /**
   * 最小辅助数量
   */
  private java.math.BigDecimal auxQtyMin;

  /**
   * 最大辅助数量
   */
  private java.math.BigDecimal auxQtyMax;

  /**
   * 辅助数量 比较(eq)
   */
  private java.math.BigDecimal auxQtyEq;
  /**
   * 辅助数量 比较(neq)
   */
  private java.math.BigDecimal auxQtyNeq;
  /**
   * 辅助数量 比较(gt)
   */
  private java.math.BigDecimal auxQtyGt;
  /**
   * 辅助数量 比较(gte)
   */
  private java.math.BigDecimal auxQtyGte;
  /**
   * 辅助数量 比较(lt)
   */
  private java.math.BigDecimal auxQtyLt;
  /**
   * 辅助数量 比较(lte)
   */
  private java.math.BigDecimal auxQtyLte;
  /**
   * 辅助数量 比较(contains)
   */
  private java.math.BigDecimal auxQtyContains;
  /**
   * 辅助数量 比较(notcontains)
   */
  private java.math.BigDecimal auxQtyNotcontains;
  /**
   * 辅助数量 比较(startswith)
   */
  private java.math.BigDecimal auxQtyStartswith;
  /**
   * 辅助数量 比较(endswith)
   */
  private java.math.BigDecimal auxQtyEndswith;
  /**
   * 辅助数量 比较(isnull)
   */
  private Boolean auxQtyIsnull;
  /**
   * 辅助数量 比较(isnotnull)
   */
  private Boolean auxQtyIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 次品在途结存量
   */
  private Long defectiveGoodsInTransit;

  /**
   * 最小次品在途结存量
   */
  private Long defectiveGoodsInTransitMin;

  /**
   * 最大次品在途结存量
   */
  private Long defectiveGoodsInTransitMax;

  /**
   * 次品在途结存量 比较(eq)
   */
  private Long defectiveGoodsInTransitEq;
  /**
   * 次品在途结存量 比较(neq)
   */
  private Long defectiveGoodsInTransitNeq;
  /**
   * 次品在途结存量 比较(gt)
   */
  private Long defectiveGoodsInTransitGt;
  /**
   * 次品在途结存量 比较(gte)
   */
  private Long defectiveGoodsInTransitGte;
  /**
   * 次品在途结存量 比较(lt)
   */
  private Long defectiveGoodsInTransitLt;
  /**
   * 次品在途结存量 比较(lte)
   */
  private Long defectiveGoodsInTransitLte;
  /**
   * 次品在途结存量 比较(contains)
   */
  private Long defectiveGoodsInTransitContains;
  /**
   * 次品在途结存量 比较(notcontains)
   */
  private Long defectiveGoodsInTransitNotcontains;
  /**
   * 次品在途结存量 比较(startswith)
   */
  private Long defectiveGoodsInTransitStartswith;
  /**
   * 次品在途结存量 比较(endswith)
   */
  private Long defectiveGoodsInTransitEndswith;
  /**
   * 次品在途结存量 比较(isnull)
   */
  private Boolean defectiveGoodsInTransitIsnull;
  /**
   * 次品在途结存量 比较(isnotnull)
   */
  private Boolean defectiveGoodsInTransitIsnotnull;

  /**
   * 可用锁定量
   */
  private Long defectiveLockAmount;

  /**
   * 最小可用锁定量
   */
  private Long defectiveLockAmountMin;

  /**
   * 最大可用锁定量
   */
  private Long defectiveLockAmountMax;

  /**
   * 可用锁定量 比较(eq)
   */
  private Long defectiveLockAmountEq;
  /**
   * 可用锁定量 比较(neq)
   */
  private Long defectiveLockAmountNeq;
  /**
   * 可用锁定量 比较(gt)
   */
  private Long defectiveLockAmountGt;
  /**
   * 可用锁定量 比较(gte)
   */
  private Long defectiveLockAmountGte;
  /**
   * 可用锁定量 比较(lt)
   */
  private Long defectiveLockAmountLt;
  /**
   * 可用锁定量 比较(lte)
   */
  private Long defectiveLockAmountLte;
  /**
   * 可用锁定量 比较(contains)
   */
  private Long defectiveLockAmountContains;
  /**
   * 可用锁定量 比较(notcontains)
   */
  private Long defectiveLockAmountNotcontains;
  /**
   * 可用锁定量 比较(startswith)
   */
  private Long defectiveLockAmountStartswith;
  /**
   * 可用锁定量 比较(endswith)
   */
  private Long defectiveLockAmountEndswith;
  /**
   * 可用锁定量 比较(isnull)
   */
  private Boolean defectiveLockAmountIsnull;
  /**
   * 可用锁定量 比较(isnotnull)
   */
  private Boolean defectiveLockAmountIsnotnull;

  /**
   * 陈列数量
   */
  private java.math.BigDecimal displayQty;

  /**
   * 最小陈列数量
   */
  private java.math.BigDecimal displayQtyMin;

  /**
   * 最大陈列数量
   */
  private java.math.BigDecimal displayQtyMax;

  /**
   * 陈列数量 比较(eq)
   */
  private java.math.BigDecimal displayQtyEq;
  /**
   * 陈列数量 比较(neq)
   */
  private java.math.BigDecimal displayQtyNeq;
  /**
   * 陈列数量 比较(gt)
   */
  private java.math.BigDecimal displayQtyGt;
  /**
   * 陈列数量 比较(gte)
   */
  private java.math.BigDecimal displayQtyGte;
  /**
   * 陈列数量 比较(lt)
   */
  private java.math.BigDecimal displayQtyLt;
  /**
   * 陈列数量 比较(lte)
   */
  private java.math.BigDecimal displayQtyLte;
  /**
   * 陈列数量 比较(contains)
   */
  private java.math.BigDecimal displayQtyContains;
  /**
   * 陈列数量 比较(notcontains)
   */
  private java.math.BigDecimal displayQtyNotcontains;
  /**
   * 陈列数量 比较(startswith)
   */
  private java.math.BigDecimal displayQtyStartswith;
  /**
   * 陈列数量 比较(endswith)
   */
  private java.math.BigDecimal displayQtyEndswith;
  /**
   * 陈列数量 比较(isnull)
   */
  private Boolean displayQtyIsnull;
  /**
   * 陈列数量 比较(isnotnull)
   */
  private Boolean displayQtyIsnotnull;

  /**
   * 关联制单人(模糊搜索)
   */
  private String formOperator;

  /**
   * 关联制单人 比较(eq)
   */
  private String formOperatorEq;
  /**
   * 关联制单人 比较(neq)
   */
  private String formOperatorNeq;
  /**
   * 关联制单人 比较(gt)
   */
  private String formOperatorGt;
  /**
   * 关联制单人 比较(gte)
   */
  private String formOperatorGte;
  /**
   * 关联制单人 比较(lt)
   */
  private String formOperatorLt;
  /**
   * 关联制单人 比较(lte)
   */
  private String formOperatorLte;
  /**
   * 关联制单人 比较(contains)
   */
  private String formOperatorContains;
  /**
   * 关联制单人 比较(notcontains)
   */
  private String formOperatorNotcontains;
  /**
   * 关联制单人 比较(startswith)
   */
  private String formOperatorStartswith;
  /**
   * 关联制单人 比较(endswith)
   */
  private String formOperatorEndswith;
  /**
   * 关联制单人 比较(isnull)
   */
  private Boolean formOperatorIsnull;
  /**
   * 关联制单人 比较(isnotnull)
   */
  private Boolean formOperatorIsnotnull;

  /**
   * 关联制单人(精确搜索)
   */
  private List<String> formOperatorInList;

  /**
   * 变动源类型(模糊搜索)
   */
  private String fromType;

  /**
   * 变动源类型 比较(eq)
   */
  private String fromTypeEq;
  /**
   * 变动源类型 比较(neq)
   */
  private String fromTypeNeq;
  /**
   * 变动源类型 比较(gt)
   */
  private String fromTypeGt;
  /**
   * 变动源类型 比较(gte)
   */
  private String fromTypeGte;
  /**
   * 变动源类型 比较(lt)
   */
  private String fromTypeLt;
  /**
   * 变动源类型 比较(lte)
   */
  private String fromTypeLte;
  /**
   * 变动源类型 比较(contains)
   */
  private String fromTypeContains;
  /**
   * 变动源类型 比较(notcontains)
   */
  private String fromTypeNotcontains;
  /**
   * 变动源类型 比较(startswith)
   */
  private String fromTypeStartswith;
  /**
   * 变动源类型 比较(endswith)
   */
  private String fromTypeEndswith;
  /**
   * 变动源类型 比较(isnull)
   */
  private Boolean fromTypeIsnull;
  /**
   * 变动源类型 比较(isnotnull)
   */
  private Boolean fromTypeIsnotnull;

  /**
   * 变动源类型(精确搜索)
   */
  private List<String> fromTypeInList;

  /**
   * 次品在途量
   */
  private Long goodsInTransit;

  /**
   * 最小次品在途量
   */
  private Long goodsInTransitMin;

  /**
   * 最大次品在途量
   */
  private Long goodsInTransitMax;

  /**
   * 次品在途量 比较(eq)
   */
  private Long goodsInTransitEq;
  /**
   * 次品在途量 比较(neq)
   */
  private Long goodsInTransitNeq;
  /**
   * 次品在途量 比较(gt)
   */
  private Long goodsInTransitGt;
  /**
   * 次品在途量 比较(gte)
   */
  private Long goodsInTransitGte;
  /**
   * 次品在途量 比较(lt)
   */
  private Long goodsInTransitLt;
  /**
   * 次品在途量 比较(lte)
   */
  private Long goodsInTransitLte;
  /**
   * 次品在途量 比较(contains)
   */
  private Long goodsInTransitContains;
  /**
   * 次品在途量 比较(notcontains)
   */
  private Long goodsInTransitNotcontains;
  /**
   * 次品在途量 比较(startswith)
   */
  private Long goodsInTransitStartswith;
  /**
   * 次品在途量 比较(endswith)
   */
  private Long goodsInTransitEndswith;
  /**
   * 次品在途量 比较(isnull)
   */
  private Boolean goodsInTransitIsnull;
  /**
   * 次品在途量 比较(isnotnull)
   */
  private Boolean goodsInTransitIsnotnull;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
